/**
 * 业务模块Store统一导出
 * 为所有业务模块提供统一的入口
 */

// 创建备用实现
const createBackupStore = (name) => {
  console.log(`创建备用${name}Store`);
  return {
    init: function() {
      console.log(`备用${name}Store.init被调用`);
      return true;
    }
  };
};

// 尝试导入各业务模块
let taskStore, TASK_STATUS, PRIORITY_LEVEL;
try {
  const taskModule = require('./task/index');
  taskStore = taskModule.taskStore || taskModule.default;
  TASK_STATUS = taskModule.TASK_STATUS;
  PRIORITY_LEVEL = taskModule.PRIORITY_LEVEL;
} catch (e) {
  console.error('加载taskStore失败，使用备用实现', e);
  taskStore = createBackupStore('task');
  TASK_STATUS = { 
    NOT_STARTED: 0, 
    IN_PROGRESS: 1, 
    COMPLETED: 2, 
    CANCELLED: 3 
  };
  PRIORITY_LEVEL = { 
    LOW: 0, 
    MEDIUM: 1, 
    HIGH: 2, 
    URGENT: 3 
  };
}

let researchStore;
try {
  const researchModule = require('./research/research');
  researchStore = researchModule.researchStore || researchModule.default;
} catch (e) {
  console.error('加载researchStore失败，使用备用实现', e);
  researchStore = createBackupStore('research');
}

let resourceStore;
try {
  const resourceModule = require('./resource/index');
  resourceStore = resourceModule.resourceStore || resourceModule.default;
} catch (e) {
  console.error('加载resourceStore失败，使用备用实现', e);
  resourceStore = createBackupStore('resource');
}

// 尝试导入UI Store
let uiStore;
try {
  const uiModule = require('./ui/index');
  uiStore = uiModule.uiStore || uiModule.default;
  
  if (!uiStore) {
    throw new Error('uiStore不存在');
  }
} catch (e) {
  console.error('加载uiStore失败，使用备用实现', e);
  uiStore = {
    theme: 'light',
    fontSize: 'normal',
    
    // 初始化方法
    init: function() {
      console.log('备用uiStore.init方法被调用');
      try {
        // 尝试从缓存加载UI设置
        const uiSettings = wx.getStorageSync('uiSettings');
        if (uiSettings) {
          this.theme = uiSettings.theme || 'light';
          this.fontSize = uiSettings.fontSize || 'normal';
        }
        return true;
      } catch (error) {
        console.error('初始化UI状态失败', error);
        return false;
      }
    }
  };
}

// 尝试导入消息Store
let messageStore;
try {
  const messageModule = require('./message/index');
  messageStore = messageModule.messageStore || messageModule.default;
  
  if (!messageStore) {
    throw new Error('messageStore不存在');
  }
} catch (e) {
  console.error('加载messageStore失败，使用备用实现', e);
  messageStore = {
    unreadCount: 0,
    messages: [],
    
    // 初始化方法
    init: function() {
      console.log('备用messageStore.init方法被调用');
      try {
        // 尝试从缓存加载消息
        const messageData = wx.getStorageSync('messageData');
        if (messageData) {
          this.unreadCount = messageData.unreadCount || 0;
          this.messages = messageData.messages || [];
        }
        return true;
      } catch (error) {
        console.error('初始化消息状态失败', error);
        return false;
      }
    }
  };
}

// 尝试导入用户Store
let userStore;
try {
  const userModule = require('./user/store_config');
  userStore = userModule.userStore;
  
  if (!userStore) {
    try {
      const userIndexModule = require('./user/index');
      userStore = userIndexModule.userStore || userIndexModule.default;
    } catch (e2) {
      throw new Error('userStore不存在: ' + e2.message);
    }
  }
} catch (e) {
  console.error('加载userStore失败，使用备用实现', e);
  userStore = {
    user: null,
    isLogin: false,
    isAdmin: false,
    
    // 初始化方法 - app.js需要调用此方法
    init: function() {
      console.log('备用userStore.init方法被调用');
      try {
        // 检查是否有登录信息
        const userInfo = wx.getStorageSync('userInfo');
        if (userInfo) {
          this.user = userInfo;
          this.isLogin = true;
          this.isAdmin = userInfo.role === 'admin';
        }
        return true;
      } catch (error) {
        console.error('初始化用户状态失败', error);
        return false;
      }
    },
    
    // 行为方法
    getUserInfo: function() {
      return this.user || null;
    }
  };
}

// 尝试导入系统模块Store
let systemStore;
try {
  const systemModule = require('./system/store_config');
  systemStore = systemModule;
  
  if (!systemStore) {
    throw new Error('systemStore不存在');
  }
} catch (e) {
  console.error('加载systemStore失败，使用备用实现', e);
  systemStore = {
    whiteStore: createBackupStore('white')
  };
}

/**
 * 初始化所有业务模块Store
 */
function initModuleStores() {
  // 任务模块初始化
  if (taskStore && taskStore.init) {
    taskStore.init();
  }
  
  // 研究模块初始化
  if (researchStore && researchStore.init) {
    researchStore.init();
  }
  
  // 资源版本管理模块初始化
  if (resourceStore && resourceStore.init) {
    resourceStore.init();
  }
  
  // UI模块初始化
  if (uiStore && uiStore.init) {
    uiStore.init();
  }
  
  // 消息模块初始化
  if (messageStore && messageStore.init) {
    messageStore.init();
  }
  
  // 用户模块初始化
  if (userStore && userStore.init) {
    userStore.init();
  }
  
  // 系统模块初始化
  if (systemStore.whiteStore && systemStore.whiteStore.init) {
    systemStore.whiteStore.init();
  }
}

// 导出所有模块
module.exports = {
  // 初始化方法
  initModuleStores,
  
  // 任务模块
  taskStore,
  TASK_STATUS,
  PRIORITY_LEVEL,
  
  // 研究模块
  researchStore,
  
  // 资源版本管理模块
  resourceStore,
  
  // UI模块
  uiStore,
  
  // 消息模块
  messageStore,
  
  // 用户模块
  userStore,
  
  // 系统模块
  systemStore
}; 